home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / pangomm-1.4 / pangomm / attributes.h next >
Encoding:
C/C++ Source or Header  |  2006-04-20  |  18.7 KB  |  671 lines
  1. // -*- c++ -*-
  2. // Generated by gtkmmproc -- DO NOT MODIFY!
  3. #ifndef _PANGOMM_ATTRIBUTES_H
  4. #define _PANGOMM_ATTRIBUTES_H
  5.  
  6. #include <glibmm.h>
  7.  
  8. /* attributes.h
  9.  *
  10.  * Copyright (C) 2002 The gtkmm Development Team
  11.  *
  12.  * This library is free software; you can redistribute it and/or
  13.  * modify it under the terms of the GNU Library General Public
  14.  * License as published by the Free Software Foundation; either
  15.  * version 2 of the License, or (at your option) any later version.
  16.  *
  17.  * This library is distributed in the hope that it will be useful,
  18.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20.  * Library General Public License for more details.
  21.  *
  22.  * You should have received a copy of the GNU Library General Public
  23.  * License along with this library; if not, write to the Free
  24.  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25.  */
  26.  
  27. #include <pangomm/language.h>
  28. #include <pangomm/rectangle.h>
  29. #include <pangomm/color.h>
  30. #include <pangomm/fontdescription.h>
  31. #include <pango/pango-attributes.h>
  32.  
  33.  
  34. namespace Pango
  35. {
  36.  
  37.  
  38. /** @addtogroup pangommEnums Enums and Flags */
  39.  
  40. /** Pango::AttrType distinguishes between different types of attributes.
  41.  * Along with the predefined values, it is possible to allocate additional values for
  42.  * custom attributes using Pango::Attribute::register_type(). The predefined values
  43.  * are given below.
  44.  * @ingroup pangommEnums
  45.  */
  46. enum AttrType
  47. {
  48.   ATTR_INVALID,
  49.   ATTR_LANGUAGE,
  50.   ATTR_FAMILY,
  51.   ATTR_STYLE,
  52.   ATTR_WEIGHT,
  53.   ATTR_VARIANT,
  54.   ATTR_STRETCH,
  55.   ATTR_SIZE,
  56.   ATTR_FONT_DESC,
  57.   ATTR_FOREGROUND,
  58.   ATTR_BACKGROUND,
  59.   ATTR_UNDERLINE,
  60.   ATTR_STRIKETHROUGH,
  61.   ATTR_RISE,
  62.   ATTR_SHAPE,
  63.   ATTR_SCALE,
  64.   ATTR_FALLBACK,
  65.   ATTR_LETTER_SPACING,
  66.   ATTR_UNDERLINE_COLOR,
  67.   ATTR_STRIKETHROUGH_COLOR,
  68.   ATTR_ABSOLUTE_SIZE
  69. };
  70.  
  71. } // namespace Pango
  72.  
  73.  
  74. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  75. namespace Glib
  76. {
  77.  
  78. template <>
  79. class Value<Pango::AttrType> : public Glib::Value_Enum<Pango::AttrType>
  80. {
  81. public:
  82.   static GType value_type() G_GNUC_CONST;
  83. };
  84.  
  85. } // namespace Glib
  86. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  87.  
  88.  
  89. namespace Pango
  90. {
  91.  
  92.  
  93. /** A Pango::Underline is used to specify whether text should be underlined, and if so, the type of underlining.
  94.  * @ingroup pangommEnums
  95.  */
  96. enum Underline
  97. {
  98.   UNDERLINE_NONE,
  99.   UNDERLINE_SINGLE,
  100.   UNDERLINE_DOUBLE,
  101.   UNDERLINE_LOW,
  102.   UNDERLINE_ERROR
  103. };
  104.  
  105. } // namespace Pango
  106.  
  107.  
  108. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  109. namespace Glib
  110. {
  111.  
  112. template <>
  113. class Value<Pango::Underline> : public Glib::Value_Enum<Pango::Underline>
  114. {
  115. public:
  116.   static GType value_type() G_GNUC_CONST;
  117. };
  118.  
  119. } // namespace Glib
  120. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  121.  
  122.  
  123. namespace Pango
  124. {
  125.  
  126.  
  127. /** A Pango::LogAttr stores information about the attributes of a single character.
  128.  */
  129. typedef PangoLogAttr LogAttr;
  130.  
  131.  
  132. class AttrString;
  133. class AttrLanguage;
  134. class AttrColor;
  135. class AttrInt;
  136. class AttrFloat;
  137. class AttrFontDesc;
  138. class AttrShape;
  139.  
  140. /** The Pango::Attribute structure represents the common portions of all attributes.
  141.  * Particular types of attributes derive this class. It holds the range in which the
  142.  * value in the type-specific part of the attribute applies.
  143.  *
  144.  * Attributed text is used in a number of places in pango. It is used as the input to
  145.  * the itemization process and also when creating a Pango::Layout.
  146.  */
  147. class Attribute
  148. {
  149.   public:
  150. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  151.   typedef Attribute CppObjectType;
  152.   typedef PangoAttribute BaseObjectType;
  153. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  154.  
  155. private:
  156.  
  157.   
  158. public:
  159.   /** Constructs an invalid attribute.
  160.    */
  161.   Attribute();
  162.  
  163.   Attribute(const Attribute& src);
  164.   explicit Attribute(PangoAttribute* castitem, bool take_copy=true);
  165.   ~Attribute();
  166.  
  167.   Attribute& operator=(const Attribute& src);
  168.  
  169.   /** Gets the type ID for this attribute.
  170.    * @return The type ID for this attribute or ATTR_INVALID if the attribute is invalid.
  171.    */
  172.   AttrType get_type() const;
  173.  
  174.   /** Allocate a new attribute type ID.
  175.    * @param name An identifier for the type (currently unused).
  176.    * @return The new type ID.
  177.    */
  178.   static AttrType register_type(const Glib::ustring& name);
  179.  
  180.   /** Gets the start index of the range.
  181.    * @return The start index of the range.
  182.    */
  183.   unsigned int get_start_index() const;
  184.  
  185.   /** Gets the end index of the range. The character at this index is not included in the range.
  186.    * @return The end index of the range.
  187.    */
  188.   unsigned int get_end_index() const;
  189.  
  190.   /** Sets the start index of the range.
  191.    * @param value The new start index.
  192.    */
  193.   void set_start_index(const unsigned int& value);
  194.  
  195.   /** Sets the end index of the range. The character at this index is not included in the range.
  196.    * @param value The new end index.
  197.    */
  198.   void set_end_index(const unsigned int& value);
  199.  
  200.   
  201.   /** Compare two attributes for equality. This compares only the
  202.    * actual value of the two attributes and not the ranges that the
  203.    * attributes apply to.
  204.    * @param attr2 Another Pango::Attribute.
  205.    * @return <tt>true</tt> if the two attributes have the same value.
  206.    */
  207.   bool equal(const Attribute& attr2) const;
  208.  
  209.   /// Provides access to the underlying C GObject.  
  210.   PangoAttribute*       gobj()       { return gobject_; }
  211.   /// Provides access to the underlying C GObject.
  212.   PangoAttribute* const gobj() const { return gobject_; }
  213.  
  214.   /** Create a new font family attribute.
  215.    * @param family The family or comma separated list of families.
  216.    * @return An attribute of type AttrString.
  217.    */
  218.   static AttrString create_attr_family(const Glib::ustring& family);
  219.  
  220.   /** Create a new language tag attribute
  221.    * @param language The language tag.
  222.    * @return An attribute of type AttrLanguage.
  223.    */
  224.   static AttrLanguage create_attr_language(const Language& language);
  225.  
  226.   /** Create a new foreground color attribute.
  227.    * @param red The red value (ranging from 0 to 65535).
  228.    * @param green The green value (ranging from 0 to 65535).
  229.    * @param blue The blue value (ranging from 0 to 65535).
  230.    * @return An attribute of type AttrColor.
  231.    */
  232.   static AttrColor create_attr_foreground(guint16 red, guint16 green, guint16 blue);
  233.  
  234.   /** Create a new background color attribute.
  235.    * @param red The red value (ranging from 0 to 65535).
  236.    * @param green The green value (ranging from 0 to 65535).
  237.    * @param blue The blue value (ranging from 0 to 65535).
  238.    * @return An attribute of type AttrColor.
  239.    */
  240.   static AttrColor create_attr_background(guint16 red, guint16 green, guint16 blue);
  241.  
  242.   /** Create a new font-size attribute.
  243.    * @param size The font size, in 1000ths of a point.
  244.    * @return An attribute of type AttrInt.
  245.    */
  246.   static AttrInt create_attr_size(int size);
  247.  
  248.   /** Create a new font slant style attribute.
  249.    * @param style The slant style.
  250.    * @return An attribute of type AttrInt.
  251.    */
  252.   static AttrInt create_attr_style(Style style);
  253.  
  254.   /** Create a new font weight attribute.
  255.    * @param weight The weight.
  256.    * @return An attribute of type AttrInt.
  257.    */
  258.   static AttrInt create_attr_weight(Weight weight);
  259.  
  260.   /** Create a new font variant attribute (normal or small caps).
  261.    * @param variant The variant.
  262.    * @return An attribute of type AttrInt.
  263.    */
  264.   static AttrInt create_attr_variant(Variant variant);
  265.  
  266.   /** Create a new font stretch attribute.
  267.    * @param stretch The stretch.
  268.    * @return An attribute of type AttrInt.
  269.    */
  270.   static AttrInt create_attr_stretch(Stretch stretch);
  271.  
  272.   /** Create a new font description attribute.
  273.    * This attribute allows setting family, style, weight, variant, stretch, and size simultaneously.
  274.    * @param desc The font description.
  275.    * @return An attribute of type AttrFontDesc.
  276.    */
  277.   static AttrFontDesc create_attr_font_desc(const FontDescription& desc);
  278.  
  279.   /** Create a new underline-style object.
  280.    * @param underline The underline style.
  281.    * @return An attribute of type AttrInt.
  282.    */
  283.   static AttrInt create_attr_underline(Underline underline);
  284.  
  285.   /** Create a new font strike-through attribute.
  286.    * @param strikethrough True indicates the text should be struck-through.
  287.    * @return An attribute of type AttrInt.
  288.    */
  289.   static AttrInt create_attr_strikethrough(bool strikethrough);
  290.  
  291.   /** Create a new baseline displacement attribute.
  292.    * @param rise The amount that the text should be displaced vertically, in 10'000ths of an em. Positive values displace the text upwards.
  293.    * @return An attribute of type AttrInt.
  294.    */
  295.   static AttrInt create_attr_rise(int rise);
  296.  
  297.   /** Create a new font size scale attribute.
  298.    * The base font for the affected text will have its size multiplied by scale_factor.
  299.    * @param scale_factor Factor to scale the font.
  300.    * @return An attribute of type AttrFloat.
  301.    */
  302.   static AttrFloat create_attr_scale(double scale_factor);
  303.  
  304.   /** Create a new shape attribute.
  305.    * A shape is used to impose a particular ink and logical rect on the result of shaping a particular glyph.
  306.    * This might be used, for instance, for embedding a picture or a widget inside a PangoLayout.
  307.    * @param ink_rect Ink rectangle to assign to each character.
  308.    * @param logical_rect Logical rectangle assign to each character.
  309.    * @return An attribute of type AttrShape.
  310.    */
  311.   static AttrShape create_attr_shape(const Rectangle& ink_rect, const Rectangle& logical_rect);
  312.  
  313. protected:
  314.   PangoAttribute* gobject_;
  315.  
  316.  
  317. };
  318.  
  319. /** @relates Pango::Attribute */
  320. inline bool operator==(const Attribute& lhs, const Attribute& rhs)
  321. {
  322.   return lhs.equal(rhs);
  323. }
  324.  
  325. /** @relates Pango::Attribute */
  326. inline bool operator!=(const Attribute& lhs, const Attribute& rhs)
  327. {
  328.   return lhs.equal(rhs);
  329. }
  330.  
  331.  
  332. /** A Pango::AttrString is used to represent an attribute with a string value.
  333.  */
  334. class AttrString : public Attribute
  335. {
  336.   public:
  337. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  338.   typedef AttrString CppObjectType;
  339.   typedef PangoAttrString BaseObjectType;
  340. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  341.  
  342. private:
  343.  
  344.  
  345. protected:
  346.   AttrString();
  347. public:
  348.   AttrString(const AttrString& src);
  349.   explicit AttrString(PangoAttrString* castitem, bool take_copy=true);
  350.  
  351.   AttrString& operator=(const AttrString& src);
  352.  
  353.   /** Gets the string which is the value of the attribute.
  354.    * @return The string value of the attribute.
  355.    */
  356.   Glib::ustring get_string() const;
  357.  
  358.   /** Sets the string which is the value of the attribute.
  359.    * @param string The new string value for the attribute.
  360.    */
  361.   void set_string(const Glib::ustring& string);
  362.  
  363.   /// Provides access to the underlying C GObject.  
  364.   PangoAttrString*       gobj()       { return reinterpret_cast<PangoAttrString*>(gobject_); }
  365.   /// Provides access to the underlying C GObject.
  366.   const PangoAttrString* gobj() const { return reinterpret_cast<const PangoAttrString*>(gobject_); }
  367.  
  368.  
  369. };
  370.  
  371.  
  372. /** A Pango::AttrLanguage is used to represent an attribute that is a language.
  373.  */
  374. class AttrLanguage : public Attribute
  375. {
  376.   public:
  377. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  378.   typedef AttrLanguage CppObjectType;
  379.   typedef PangoAttrLanguage BaseObjectType;
  380. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  381.  
  382. private:
  383.  
  384.  
  385. protected:
  386.   AttrLanguage();
  387. public:
  388.   AttrLanguage(const AttrLanguage& src);
  389.   explicit AttrLanguage(PangoAttrLanguage* castitem, bool take_copy=true);
  390.  
  391.   AttrLanguage& operator=(const AttrLanguage& src);
  392.  
  393.   /** Gets the language which is the value of the attribute.
  394.    * @return The language tag of the attribute.
  395.    */
  396.   Language get_language() const;
  397.  
  398.   /** Sets the language which is the value of the attribute.
  399.    * @param value The new language tag for the attribute.
  400.    */
  401.   void set_language(const Language& value);
  402.  
  403.   /// Provides access to the underlying C GObject.  
  404.   PangoAttrLanguage*       gobj()       { return reinterpret_cast<PangoAttrLanguage*>(gobject_); }
  405.   /// Provides access to the underlying C GObject.
  406.   const PangoAttrLanguage* gobj() const { return reinterpret_cast<const PangoAttrLanguage*>(gobject_); }
  407.  
  408.  
  409. };
  410.  
  411.  
  412. /** A Pango::AttrColor is used to represent an attribute which is a color.
  413.  */
  414. class AttrColor : public Attribute
  415. {
  416.   public:
  417. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  418.   typedef AttrColor CppObjectType;
  419.   typedef PangoAttrColor BaseObjectType;
  420. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  421.  
  422. private:
  423.  
  424.  
  425. protected:
  426.   AttrColor();
  427. public:
  428.   AttrColor(const AttrColor& src);
  429.   explicit AttrColor(PangoAttrColor* castitem, bool take_copy=true);
  430.  
  431.   AttrColor& operator=(const AttrColor& src);
  432.  
  433.   /** Gets the color which is the value of the attribute.
  434.    * @return The color value of the attribute.
  435.    */
  436.   Color get_color() const;
  437.  
  438.   /** Sets the color which is the value of the attribute.
  439.    * @param value The new color value for the attribute.
  440.    */
  441.   void set_color(const Color& value);
  442.  
  443.   /// Provides access to the underlying C GObject.  
  444.   PangoAttrColor*       gobj()       { return reinterpret_cast<PangoAttrColor*>(gobject_); }
  445.   /// Provides access to the underlying C GObject.
  446.   const PangoAttrColor* gobj() const { return reinterpret_cast<const PangoAttrColor*>(gobject_); }
  447.  
  448.  
  449. };
  450.  
  451.  
  452. /** A Pango::AttrInt is used to represent an attribute with an integer or enumeration value.
  453.  */
  454. class AttrInt : public Attribute
  455. {
  456.   public:
  457. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  458.   typedef AttrInt CppObjectType;
  459.   typedef PangoAttrInt BaseObjectType;
  460. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  461.  
  462. private:
  463.  
  464.  
  465. protected:
  466.   AttrInt();
  467. public:
  468.   AttrInt(const AttrInt& src);
  469.   explicit AttrInt(PangoAttrInt* castitem, bool take_copy=true);
  470.  
  471.   AttrInt& operator=(const AttrInt& src);
  472.  
  473.   /** Gets the integer value of the attribute.
  474.    * @return The integer value of the attribute.
  475.    */
  476.   int get_value() const;
  477.  
  478.   /** Sets the integer value of the attribute.
  479.    * @param value The new integer value for the attribute.
  480.    */
  481.   void set_value(const int& value);
  482.  
  483.   /// Provides access to the underlying C GObject.  
  484.   PangoAttrInt*       gobj()       { return reinterpret_cast<PangoAttrInt*>(gobject_); }
  485.   /// Provides access to the underlying C GObject.
  486.   const PangoAttrInt* gobj() const { return reinterpret_cast<const PangoAttrInt*>(gobject_); }
  487.  
  488.  
  489. };
  490.  
  491.  
  492. /** A Pango::AttrFloat is used to represent an attribute with a float or double value.
  493.  */
  494. class AttrFloat : public Attribute
  495. {
  496.   public:
  497. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  498.   typedef AttrFloat CppObjectType;
  499.   typedef PangoAttrFloat BaseObjectType;
  500. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  501.  
  502. private:
  503.  
  504.  
  505. protected:
  506.   AttrFloat();
  507. public:
  508.   AttrFloat(const AttrFloat& src);
  509.   explicit AttrFloat(PangoAttrFloat* castitem, bool take_copy=true);
  510.  
  511.   AttrFloat& operator=(const AttrFloat& src);
  512.  
  513.   /** Gets the floating point value of the attribute.
  514.    * @return The floating point value of the attribute.
  515.    */
  516.   double get_value() const;
  517.  
  518.   /** Sets the floating point value of the attribute.
  519.    * @param value The new floating point value for the attribute.
  520.    */
  521.   void set_value(const double& value);
  522.  
  523.   /// Provides access to the underlying C GObject.
  524.   PangoAttrFloat*       gobj()       { return reinterpret_cast<PangoAttrFloat*>(gobject_); }
  525.   /// Provides access to the underlying C GObject.
  526.   const PangoAttrFloat* gobj() const { return reinterpret_cast<const PangoAttrFloat*>(gobject_); }
  527.  
  528.  
  529. };
  530.  
  531.  
  532. /** A Pango::AttrFontDesc is used to represent an attribute that sets all aspects of the font description at once.
  533.  */
  534. class AttrFontDesc : public Attribute
  535. {
  536.   public:
  537. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  538.   typedef AttrFontDesc CppObjectType;
  539.   typedef PangoAttrFontDesc BaseObjectType;
  540. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  541.  
  542. private:
  543.  
  544.  
  545. protected:
  546.   AttrFontDesc();
  547. public:
  548.   AttrFontDesc(const AttrFontDesc& src);
  549.   explicit AttrFontDesc(PangoAttrFontDesc* castitem, bool take_copy=true);
  550.  
  551.   AttrFontDesc& operator=(const AttrFontDesc& src);
  552.  
  553.   /** Gets the font description which is the value of the attribute.
  554.    * @return The font description of the attribute.
  555.    */
  556.   FontDescription get_desc() const;
  557.  
  558.   /** Sets the font description which is the value of the attribute.
  559.    * @param desc The new font description for the attribute.
  560.    */
  561.   void set_desc(const FontDescription& desc);
  562.   
  563.   /// Provides access to the underlying C GObject.
  564.   PangoAttrFontDesc*       gobj()       { return reinterpret_cast<PangoAttrFontDesc*>(gobject_); }
  565.   /// Provides access to the underlying C GObject.
  566.   const PangoAttrFontDesc* gobj() const { return reinterpret_cast<const PangoAttrFontDesc*>(gobject_); }
  567.  
  568.  
  569. };
  570.  
  571.  
  572. /** A Pango::AttrShape structure is used to represent an attribute which imposes shape restrictions.
  573.  */
  574. class AttrShape : public Attribute
  575. {
  576.   public:
  577. #ifndef DOXYGEN_SHOULD_SKIP_THIS
  578.   typedef AttrShape CppObjectType;
  579.   typedef PangoAttrShape BaseObjectType;
  580. #endif /* DOXYGEN_SHOULD_SKIP_THIS */
  581.  
  582. private:
  583.  
  584.  
  585. protected:
  586.   AttrShape();
  587. public:
  588.   AttrShape(const AttrShape& src);
  589.   explicit AttrShape(PangoAttrShape* castitem, bool take_copy=true);
  590.  
  591.   AttrShape& operator=(const AttrShape& src);
  592.  
  593.   /** Gets the ink rectangle to restrict to.
  594.    * @return The ink rectangle of the attribute.
  595.    */
  596.   Rectangle get_ink_rect() const;
  597.  
  598.   /** Gets the logical rectangle to restrict to.
  599.    * @return The logical rectangle of the attribute.
  600.    */
  601.   Rectangle get_logical_rect() const;
  602.  
  603.   /** Sets the ink rectangle to restrict to.
  604.    * @param value The new ink rectangle for the attribute.
  605.    */
  606.   void set_ink_rect(const Rectangle& value);
  607.  
  608.   /** Sets the logical rectangle to restrict to.
  609.    * @param value The new logical rectangle for the attribute.
  610.    */
  611.   void set_logical_rect(const Rectangle& value);
  612.  
  613.   /// Provides access to the underlying C GObject.  
  614.   PangoAttrShape*       gobj()       { return reinterpret_cast<PangoAttrShape*>(gobject_); }
  615.   /// Provides access to the underlying C GObject.
  616.   const PangoAttrShape* gobj() const { return reinterpret_cast<const PangoAttrShape*>(gobject_); }
  617.  
  618.  
  619. };
  620.  
  621.  
  622. struct AttributeTraits
  623. {
  624.   typedef Pango::Attribute      CppType;
  625.   typedef const PangoAttribute* CType;
  626.   typedef PangoAttribute*       CTypeNonConst;
  627.  
  628.   static CType   to_c_type      (const CppType& obj) { return obj.gobj(); }
  629.   static CType   to_c_type      (CType ptr) { return ptr; }
  630.   static CppType to_cpp_type    (CType ptr) { return CppType(const_cast<CTypeNonConst>(ptr), true); }
  631.   static void    release_c_type (CType ptr) { pango_attribute_destroy(const_cast<CTypeNonConst>(ptr)); }
  632. };
  633.  
  634. typedef Glib::SListHandle<Attribute, AttributeTraits> SListHandle_Attribute;
  635.  
  636. } // namespace Pango
  637.  
  638.  
  639. namespace Glib
  640. {
  641.  
  642. /** @relates Pango::Attribute */
  643. Pango::Attribute wrap(PangoAttribute* object, bool take_copy = false);
  644.  
  645. /** @relates Pango::AttrString */
  646. Pango::AttrString wrap(PangoAttrString* object, bool take_copy = false);
  647.  
  648. /** @relates Pango::AttrLanguage */
  649. Pango::AttrLanguage wrap(PangoAttrLanguage* object, bool take_copy = false);
  650.  
  651. /** @relates Pango::AttrColor */
  652. Pango::AttrColor wrap(PangoAttrColor* object, bool take_copy = false);
  653.  
  654. /** @relates Pango::AttrInt */
  655. Pango::AttrInt wrap(PangoAttrInt* object, bool take_copy = false);
  656.  
  657. /** @relates Pango::AttrFloat */
  658. Pango::AttrFloat wrap(PangoAttrFloat* object, bool take_copy = false);
  659.  
  660. /** @relates Pango::AttrFontDesc */
  661. Pango::AttrFontDesc wrap(PangoAttrFontDesc* object, bool take_copy = false);
  662.  
  663. /** @relates Pango::AttrShape */
  664. Pango::AttrShape wrap(PangoAttrShape* object, bool take_copy = false);
  665.  
  666. } //namespace Glib
  667.  
  668.  
  669. #endif /* _PANGOMM_ATTRIBUTES_H */
  670.  
  671.